/*
    epoll 模型实现网络通讯的服务端  
*/
#include <iostream>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/epoll.h>
#include <arpa/inet.h>

// 初始化服务端的监听端口
int initserver(int port);

int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        std::cout << "Usgae:./tcpepoll port" <<std::endl;
        return -1;
    }
    
    // 初始化服务端用于监听的socket
    int listen_sock = initserver(std::atoi(argv[1]));
    std::cout << "listen_sock=" << listen_sock <<std::endl;

    if (listen_sock < 0)
    {
        std::cout << "initserver() failed" <<std::endl;
        return -1;
    }
    /*
        读事件
            1、已连接队列中有已经准备好的socket（有新的客户端连上来了）
            2、接收缓存中有数据可以读（对端发送的报文已到达）
            3、tcp连接一下已断开（对端调用close函数关闭了连接）
        写事件
            发送缓冲区没有满，可以写入数据（可以向对端发送报文）
    */
    
    // 创建epoll句柄
    int epoll_fd = epoll_create(1);
    // 为服务端的listen_sock准备读事件
    epoll_event ev;  // 事件的数据结构
    ev.data.fd = listen_sock;  // 指定事件的自定义数据，回随着epoll_wait()返回的事件一并返回
    ev.events = EPOLLIN;  // 打算让epollo监听listen_sock的读事件

    // 把需要监听的socket加入到epoll_fd中
    epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listen_sock, &ev);

    // 存放epoll返回的事件
    epoll_event evs[10];

    while (true)
    {
        // 等待监听的socket有事件发生  10表示evs的长度是10,10000表示超时时间为10s 
        int infds = epoll_wait(epoll_fd, evs, 10, 10000);

        if (infds < 0)
        {
            // 调用epoll_wait失败
            perror("epoll_wait() failed");
            break;
        }
        
        if (infds == 0)
        {
            // epoll_wait() 超时
            perror("epoll_wait() timeout");
            continue;
        }
        
        // 如果infds>0 表示有事件发生，infds存放了发生事件的个数
        for (int i = 0; i < infds; i++)
        {   
            if (evs[i].data.fd == listen_sock)
            {
                // 如果发生事件的是listensock 表示已连接队列中有已准备好的socket(有新的客户端连上来了)
                struct sockaddr_in client;
                socklen_t len = sizeof(client);
                int client_sock = accept(listen_sock, (struct sockaddr *)&client, &len);
                if (client_sock < 0)
                {
                    perror("accept failed");
                    continue;
                }
                std::cout << "accept client(socket=)" << client_sock <<std::endl;

                // 为新客户转呗可读事件，并添加到epoll中
                ev.data.fd = client_sock;
                ev.events = EPOLLIN;
                epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_sock, &ev);
            }
            else
            {
                // 如果是客户端连接的socket有事件，表示接受缓存中有数据可以读(对端发送的报文已到达)，或者有客户端已断开连接
                char buffer[1024];
                memset(buffer, 0, sizeof(buffer));
                if (recv(evs[i].data.fd, buffer, sizeof(buffer), 0) <= 0)
                {
                    // 如果客户端的连接已断开
                    std::cout << "client(i="  << evs[i].data.fd << ") disconnected" <<std::endl;
                    // 关闭客户端的socket
                    close(evs[i].data.fd);
                }
                else
                {
                    std::cout << "recv(i=" << evs[i].data.fd << "):" << buffer <<std::endl;
                    send(evs[i].data.fd, buffer, strlen(buffer), 0);  // 将接受到的消息原发送回去
                }
            }
        }
    }
    return 0;
}


int initserver(int port)
{
    int sock = socket(AF_INET, SOCK_STREAM, 0);

    if (sock < 0)
    {
        perror("socket() failed");
        return -1;
    }
    
    int opt = 1;
    unsigned int len = sizeof(opt);
    setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, len);

    struct sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(port);

    if (bind(sock, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0)
    {
        perror("bind() failed");
        return -1;
    }
    
    if (listen(sock, 5) != 0)
    {
        perror("listen() failed");
        return -1;
    }
    return sock;
}
